Packages

library(gt)

## Warning: package 'gt' was built under R version 4.3.3

library(gtExtras)

## Warning: package 'gtExtras' was built under R version 4.3.3

library(dplyr) # for pipeline stuff

## 
## Attaching package: 'dplyr'

## The following objects are masked from 'package:stats':
## 
##     filter, lag

## The following objects are masked from 'package:base':
## 
##     intersect, setdiff, setequal, union

library(htmltools) # for tagList

## Warning: package 'htmltools' was built under R version 4.3.3

library(svglite) # for sparkline plots

## Warning: package 'svglite' was built under R version 4.3.3

library(webshot2) # for saving a gt object as a png

## Warning: package 'webshot2' was built under R version 4.3.3

What is GT (grammar of tables)

Visualization isn’t just graphs, it also includes tables. Today we’re going to look at a package that uses the grammar of graphics principles of working in layers and treating graphs as objects that can be added onto, and applying them to tables.

(Diagram from: https://towardsdatascience.com/exploring-the-gt-grammar-of-tables-package-in-r-7fff9d0b40cd and https://gt.rstudio.com/ )

Basic GT tables

(Copied from https://r-graph-gallery.com/package/gt.html with some added commentary)

First, we’ll set up some data. TO DO: Replace with sports data.

# Create a simple data frame
data = data.frame(
  Country = c("USA", "China", "India", "Brazil"),
  Capitals = c("Washington D.C.", "Beijing", "New Delhi", "Brasília"),
  Population = c(331, 1441, 1393, 212),
  GDP = c(21.43, 14.34, 2.87, 1.49)
)

Then we’ll put that data.frame into a gt() table just as we would do a with a ggplot(). The pipeline operator %>% means “take what’s on the left, and place it into the first argument in the function on the right. With tidyverse functions like ggplot and gt, the first argument is always the dataset.

# Alternatively you can do (same output):
#gt(data)

# Use the gt function
data %>%
  gt()

Basic GT tables - Titles

Titles can be added, and markdown text editing can be applied to the title and subtitle as long as you have the md() function wrapping around the text.

Notice the markdown, that the double stars ** indicate bold, the single stars * indicate italics, and the the single slanted quotations \`` indicate a code block.

data %>%
  gt() %>%
    tab_header(title = md("What a **nice title**"),
               subtitle = md("Pretty *cool subtitle* too, `isn't it?`"))

Basic GT tables - Titles

Notice that we don’t need to specify the data again, we technically don’t even need to specify the table again if we save the table as an object like we would with a graph.

basic_gt <- data %>% gt()

basic_gt %>%
    tab_header(title = "Basic text can go here too",
               subtitle = md("You *need* to have the `md()` wrapper to do more"))

Basic GT tables - Titles

We can also use HTML instead of markdown. There isn’t a way to change the colour of text like this with markdown, unfortunately.

# create and display the gt table 
data %>%
  gt() %>%
    tab_header(title = html("<span style='color:red;'>A red title</span>"))

Basic GT tables - Titles

We can add images too, using HTML. (It doesn’t matter if you use html() or HTML())

data %>%
  gt() %>%
    tab_header(title = html("<span style='color:red;'>A <strong>red</strong> title</span>"),
               subtitle = tagList(
                 tags$div(style = css(`text-align` = "center"),
                          HTML(web_image("https://www.r-project.org/logo/Rlogo.png")
                     )
                   )
                 )
               )

A red title
Country	Capitals	Population	GDP
USA	Washington D.C.	331	21.43
China	Beijing	1441	14.34
India	New Delhi	1393	2.87
Brazil	Brasília	212	1.49

Basic GT tables - Titles

You can include an image using markdown as well.

data %>%
  gt() %>%
    tab_header(title = md("![](uwaggsLogo.png){width=30%}"))

Country	Capitals	Population	GDP
USA	Washington D.C.	331	21.43
China	Beijing	1441	14.34
India	New Delhi	1393	2.87
Brazil	Brasília	212	1.49

Basic GT tables - Footers

We can also use HTML instead of markdown. There isn’t a way to change the colour of text like this with markdown, unfortunately.

tab_footer() behaves a lot like tab_header(), but for the bottom of the table.

data %>%
  gt() %>%
    tab_footnote(footnote = md("This text is the footer of this **table**"))

Basic GT tables - Footers

data2 = data.frame(
  Planet = c("Earth", "Mars", "Jupiter", "Venus"),
  Moons = c(1, 2, 79, 0),
  Distance_from_Sun = c(149.6, 227.9, 778.3, 108.2),
  Diameter = c(12742, 6779, 139822, 12104)
)

We can do multiple footnotes, and we can specify for all footnotes whether the superscripts should be numbers, letters, LETTERS, standard symbolic marks, or extended symbolic marks.

data2 %>%
  gt() %>%
    tab_footnote(footnote = md("Measured in **millions** of Km"),
                 locations = cells_column_labels(columns = Distance_from_Sun)) %>%
    tab_footnote(footnote = md("Measured in **Km**"),
                 locations = cells_column_labels(columns = Diameter)) %>%
    tab_footnote(footnote = md("The original data are from *Some Organization*")) %>%
    opt_footnote_marks(marks = "LETTERS")

data2 %>%
  gt() %>%
    tab_footnote(footnote = md("Measured in **millions** of Km"),
                 locations = cells_column_labels(columns = Distance_from_Sun)) %>%
    tab_footnote(footnote = md("Measured in **Km**"),
                 locations = cells_column_labels(columns = Diameter)) %>%
    tab_footnote(footnote = md("The original data are from *Some Organization*")) %>%
    opt_footnote_marks(marks = "extended")

Basic GT tables - Footers

We can also refer to certain elements with headers and footers.

data %>%
  gt() %>%
    tab_footnote(footnote = md("English name"),
                 locations = cells_column_labels(columns = Country))

Basic GT tables - Spanners

We can also add things like superheaders for titles when we want to group certain columns together. Notice here that the order in which we add the tab_spanner() elements doesn’t matter; we can add the two on the right before we add the two on the left.

basic_gt %>%
   tab_spanner(
    label = "Number",
    columns = c(GDP, Population)) %>%
  tab_spanner(
    label = "Label",
    columns = c(Country, Capitals)
  )

Basic GT tables - Spanners

Notice here that the Capitals column has two labels. The most recently added tab_spanner goes on the top in that case. Also notice that the columns selected do not need to be contiguous. If you need to rearrange the variables themselves, that can be done to the original data.frame.

basic_gt %>%
   tab_spanner(
    label = "Label One",
    columns = c(GDP, Capitals)) %>%
  tab_spanner(
    label = "Label Two",
    columns = c(Country, Capitals)
  )

GT Extras

Taken from https://r-graph-gallery.com/368-plotting-in-cells-with-gtextras.html

If you want to put charts in the cells of a table, you necessarily need to aggregate your data at some point. This is because you can’t really create any chart with a single value.

In this post, we’ll work with the iris dataset. This dataset has 5 columns: 4 quantitative and 1 qualitative (Species, with 3 distinct labels). A simple way to aggregate these data is to group by the Species column.

It implies that we will have a new dataset with 3 rows and as much column. Now that we have grouped by the dataset, we need to use an aggregation measure for the quantitative columns. And because we want to create chart for those cols, the aggregation will be the list of all values for the given species.

Here’s how to do it:

# load the dataset
data(iris)
head(iris)

##   Sepal.Length Sepal.Width Petal.Length Petal.Width Species
## 1          5.1         3.5          1.4         0.2  setosa
## 2          4.9         3.0          1.4         0.2  setosa
## 3          4.7         3.2          1.3         0.2  setosa
## 4          4.6         3.1          1.5         0.2  setosa
## 5          5.0         3.6          1.4         0.2  setosa
## 6          5.4         3.9          1.7         0.4  setosa

tail(iris)

##     Sepal.Length Sepal.Width Petal.Length Petal.Width   Species
## 145          6.7         3.3          5.7         2.5 virginica
## 146          6.7         3.0          5.2         2.3 virginica
## 147          6.3         2.5          5.0         1.9 virginica
## 148          6.5         3.0          5.2         2.0 virginica
## 149          6.2         3.4          5.4         2.3 virginica
## 150          5.9         3.0          5.1         1.8 virginica

This will create a list of 50 elements in each cell of the data.frame including the 50 values for that variable for that species.

# create aggregated dataset
agg_iris = iris %>%
  group_by(Species) %>%
  summarize(
    Sepal.L = list(Sepal.Length),
    Sepal.W = list(Sepal.Width),
    Petal.L = list(Petal.Length),
    Petal.W = list(Petal.Width)
    )

GT Extras

This will take that data frame of lists and make it a gt table.

# display the table with default output with gt package
agg_iris %>%
  gt()

GT Extras - Plots

The gt_plt_sparkline() function creates a line chart in table cells. It requires to add a line of code for each column you want to display. In our case, it means one line of code for each column.

In a sparkline, the highest value and the lowest value are marked, and the rest is just a line plot of the values.

# Needs svglite package
agg_iris %>%
  gt() %>%
  gt_plt_sparkline(Sepal.L) %>%
  gt_plt_sparkline(Sepal.W) %>%
  gt_plt_sparkline(Petal.L) %>%
  gt_plt_sparkline(Petal.W)

GT Extras - Plots

We can also look at distribution plots of these lists with the gt_plt_dist function, in which we specify the variable name, and the type of plot. All four options for density plots are shown here: density (KDE), boxplot, histogram, and rug_strip.

Other plotting functions include:

• gt_plt_bar_pct(),
• gt_plt_bar_stack(),
• gt_plt_bar(),
• gt_plt_percentile(),
• gt_plt_point(),
• gt_plt_sparkline(), and
• gt_plt_winloss()

agg_iris %>%
  gt() %>% 
  gt_plt_dist(Sepal.L, type = "density") %>%
  gt_plt_dist(Sepal.W, type = "boxplot") %>%
  gt_plt_dist(Petal.L, type = "histogram") %>%
  gt_plt_dist(Petal.W, type = "rug_strip")

GT Extras - Plots

The gt_plt_bar_pct() does not require aggregate data. The chart is actually a score bar that measures how close the value in the cell is to the maximum value in that column OF THE VALUES THAT ARE INCLUDED IN THE TABLE.

This means that the highest value in the table has its bar full.

Notice here that we’re only using the first six rows of data, so the percentages are of the maximum of the first six rows, not the whole thing.

head(iris) %>%
  gt() %>%
  gt_plt_bar_pct(Sepal.Length, labels = TRUE) %>%
  gt_plt_bar_pct(Sepal.Width, labels=FALSE, fill = "forestgreen")

GT Extras - Plots

The gt_plt_summary() can, in just one single line of code, summarizes your entire dataset.

If you have correctly specified the data type in your dataframe, it will automatically aggregate columns and display the right chart for them!

Notice that all 150 rows of iris are going into this, and that we’re not doing anything to aggregate them beforehand.

iris %>%
  gt_plt_summary()

## Warning in geom_point(data = NULL, aes(x = rng_vals[1], y = 1), color = "transparent", : All aesthetics have length 1, but the data has 150 rows.
## ℹ Did you mean to use `annotate()`?

## Warning in geom_point(data = NULL, aes(x = rng_vals[2], y = 1), color = "transparent", : All aesthetics have length 1, but the data has 150 rows.
## ℹ Did you mean to use `annotate()`?

## Warning in geom_point(data = NULL, aes(x = rng_vals[1], y = 1), color = "transparent", : All aesthetics have length 1, but the data has 150 rows.
## ℹ Did you mean to use `annotate()`?

## Warning in geom_point(data = NULL, aes(x = rng_vals[2], y = 1), color = "transparent", : All aesthetics have length 1, but the data has 150 rows.
## ℹ Did you mean to use `annotate()`?

## Warning in geom_point(data = NULL, aes(x = rng_vals[1], y = 1), color = "transparent", : All aesthetics have length 1, but the data has 150 rows.
## ℹ Did you mean to use `annotate()`?

## Warning in geom_point(data = NULL, aes(x = rng_vals[2], y = 1), color = "transparent", : All aesthetics have length 1, but the data has 150 rows.
## ℹ Did you mean to use `annotate()`?

## Warning in geom_point(data = NULL, aes(x = rng_vals[1], y = 1), color = "transparent", : All aesthetics have length 1, but the data has 150 rows.
## ℹ Did you mean to use `annotate()`?

## Warning in geom_point(data = NULL, aes(x = rng_vals[2], y = 1), color = "transparent", : All aesthetics have length 1, but the data has 150 rows.
## ℹ Did you mean to use `annotate()`?

GT Extras - Themes

(Code taken from the help files of gtExtras)

We can apply several premade themes using gt_theme_??? where ??? is any of several options.

This includes the ESPN website style:

themed_tab <- head(mtcars) %>%
  gt() %>%
  gt_theme_espn()

themed_tab

GT Extras - Themes

A dot-matrix printer style with fixed width text.

themed_tab2 <- head(mtcars) %>%
  gt() %>%
  gt_theme_dot_matrix()

themed_tab2

GT Extra - Themes

Or the New York Times style of publishing tables

themed_tab3 <- head(mtcars) %>%
  gt() %>%
  gt_theme_nytimes()

themed_tab3

Other Themes include:

• gt_plt_bullet(),
• gt_plt_conf_int(),
• gt_plt_dot(),
• gt_theme_538(),
• gt_theme_dark(),
• gt_theme_excel(),
• gt_theme_guardian(),
• gt_theme_pff()

GT Case Study - Palmer Penguins

Taken from: https://towardsdatascience.com/exploring-the-gt-grammar-of-tables-package-in-r-7fff9d0b40cd

Notice how gt() respects the group_by function by adding spacer rows in between islands.

penguins = read.csv("Penguins_clean.csv")

pendata <- penguins %>%
          tibble() %>% # convert from data.frame to tidyverse tibble
          filter(species == "Adelie") %>%
          group_by(island, year) %>%
          summarise_if(is.numeric, sum)

pendata

## # A tibble: 9 × 10
## # Groups:   island [3]
##   island     year bill_length_mm_female bill_length_mm_male bill_depth_mm_female
##   <chr>     <int>                 <dbl>               <dbl>                <dbl>
## 1 Biscoe     2007                  187.                196.                 92.9
## 2 Biscoe     2008                  330.                367.                155  
## 3 Biscoe     2009                  305.                330.                142. 
## 4 Dream      2007                  341.                404.                161. 
## 5 Dream      2008                  290.                321.                142. 
## 6 Dream      2009                  366.                397.                173. 
## 7 Torgersen  2007                  306.                279.                145. 
## 8 Torgersen  2008                  293.                327.                139. 
## 9 Torgersen  2009                  302.                327.                137. 
## # ℹ 5 more variables: bill_depth_mm_male <dbl>, flipper_length_mm_female <int>,
## #   flipper_length_mm_male <int>, body_mass_g_female <dbl>,
## #   body_mass_g_male <dbl>

pentab = pendata %>% gt()

pentab

GT Case Study - Palmer Penguins

In library(gt), the data_color function adds colours to data cells.

pentab2 <- pentab %>% data_color(palette = "PuOr")
pentab2

GT Case Study - Palmer Penguins

We can specify columns (and rows), and use any one of 25 palettes available from RColorBrewer or viridis. (Or make our own if we have a team theme to go for)

See ?data_color for the rest of the available palettes.

pentab3 <- pentab %>% data_color(palette = "Spectral",
                              columns = c(bill_length_mm_male, bill_depth_mm_male, 
                            flipper_length_mm_male, body_mass_g_male,
                            bill_length_mm_female, bill_depth_mm_female,
                            flipper_length_mm_female, body_mass_g_female))

pentab3

Grouping variables

(Heavily modified from https://themockup.blog/static/resources/gt-cookbook.html )

We can use a variable in the dataset as a grouping variable to put break lines into the output table when outputting a dataset as a table.

To demonstrate this, first, let’s take a few rows and columns from mtcars.

mtcars_mini = mtcars[1:10, c("cyl","gear","hp","wt","mpg")]
mtcars_mini %>% gt() 

Now let’s use the groupname_col option in gt to establish a column as the group name. Notice that cyl disappears from the column and appears as breaker. (adding a group_by() line before gt() does the same thing)

mtcars_mini %>% 
  gt(groupname_col = "cyl")

Grouping variables

We can also make the grouping variable a character variable and it works the same way. Notice that the dplyr function mutute changes the values of the variable, not the name of the variable, so we can see refer to cyl in the gt() line.

mtcars_mini %>% 
   mutate(cyl = paste(cyl, "Cylinders"))

##                           cyl gear  hp    wt  mpg
## Mazda RX4         6 Cylinders    4 110 2.620 21.0
## Mazda RX4 Wag     6 Cylinders    4 110 2.875 21.0
## Datsun 710        4 Cylinders    4  93 2.320 22.8
## Hornet 4 Drive    6 Cylinders    3 110 3.215 21.4
## Hornet Sportabout 8 Cylinders    3 175 3.440 18.7
## Valiant           6 Cylinders    3 105 3.460 18.1
## Duster 360        8 Cylinders    3 245 3.570 14.3
## Merc 240D         4 Cylinders    4  62 3.190 24.4
## Merc 230          4 Cylinders    4  95 3.150 22.8
## Merc 280          6 Cylinders    4 123 3.440 19.2

mtcars_mini %>% 
  mutate(cyl = paste(cyl, "Cylinders")) %>% 
  gt(groupname_col = "cyl")

Grouping variables

We can use multiple grouping variables too, where later-listed variables are treated as subgroups.

(See https://themockup.blog/static/resources/gt-cookbook.html#custom-groups for information on custom groups like splitting a continuous variable, or by the first letter of a name.)

mtcars_mini %>% 
  mutate(cyl = paste(cyl, "Cylinders"), gear = paste(gear, "Gears")) %>% 
  gt(groupname_col = c("cyl","gear"))

Group variables

We can arrange to put the groups on the side instead of as inserts by using rowname_col instead of groupname_col. This only seems to work with a single variable (but I may be wrong)

mtcars_mini %>% 
  mutate(cyl = paste(cyl, "Cylinders")) %>% 
  gt(rowname_col = "cyl")

Saving gt objects

You can save the output of a gt object as HTML or LaTeX code, or as a PNG or PDF image, or at RTF (Rich text format) output. gtsave() will guess what format you want from the file name.

mtcars_famcy <- mtcars %>% 
  mutate(cyl = paste(cyl, "Cylinders")) %>% 
  gt(rowname_col = "cyl")

gtsave(mtcars_famcy, "mtcars.pdf")
gtsave(mtcars_famcy, "mtcars.html")
gtsave(mtcars_famcy, "mtcars.png") # requires webshot2 package

Conditional formatting

gt() can do conditional formatting too.

stocks <- data.frame(
  Symbol = c("GOOG", "FB", "AMZN", "NFLX", "TSLA"),
  Price = c(1265.13, 187.89, 1761.33, 276.82, 328.13),
  Change = c(4.14, 1.51, -19.45, 5.32, -12.45)
)

stocks %>% gt()

Conditional formatting

This is done with tab_style, which has a few settings you need.

• style = <thing to set>, in this case, we’re changing the cell_text.
• locations = <where to set it>, in this case, we’re choosing the variable Change only for certain rows.

stocks %>% 
  gt() %>% 
  tab_style(
    style = cell_text(color = "red", weight = "bold"),
    locations = cells_body(
      columns = c(Change, Price),
      rows = Change < 0)) %>% 
  tab_style(
    style = cell_text(color = "blue", style = "italic"),
    locations = cells_body(
      columns = c(Change, Price),
      rows = Change >= 0))

Table customization

With opt_... we can apply table customization options.

mtcars_mini %>% 
  gt() %>% 
  opt_table_lines("all")

Table customization

With opt_... we can apply table customization options.

mtcars_mini %>% 
  gt() %>% 
   opt_table_outline()

Table customization

We can even use google_font to pull down fonts from Google and use those. See https://fonts.google.com/ for demos.

mtcars_mini %>% 
  gt() %>% 
opt_table_font(font = list(google_font(name = "Merriweather"), "Cochin", "Serif"))

Table customization

Other table option functions include:

• opt_align_table_header(),
• opt_all_caps(),
• opt_css(),
• opt_footnote_marks(),
• opt_footnote_spec(),
• opt_horizontal_padding(),
• opt_interactive(),
• opt_row_striping(),
• opt_stylize(),
• opt_table_font(), and
• opt_vertical_padding()

Extenal images

We can bring in external images like team logos with with gt_img_rows. First we need the URLs of the images.

teams <- "https://github.com/nflverse/nflfastR-data/raw/master/teams_colors_logos.rds"
team_df <- readRDS(url(teams)) 

team_df <- tail(team_df) %>% 
  dplyr::select(team_wordmark, team_abbr, logo = team_logo_espn, team_name:team_conf)
team_df

## # A tibble: 6 × 7
##   team_wordmark            team_abbr logo  team_name team_id team_nick team_conf
##   <chr>                    <chr>     <chr> <chr>     <chr>   <chr>     <chr>    
## 1 https://github.com/nflv… SEA       http… Seattle … 4600    Seahawks  NFC      
## 2 https://github.com/nflv… SF        http… San Fran… 4500    49ers     NFC      
## 3 https://github.com/nflv… STL       http… St. Loui… 2510    Rams      NFC      
## 4 https://github.com/nflv… TB        http… Tampa Ba… 4900    Buccanee… NFC      
## 5 https://github.com/nflv… TEN       http… Tennesse… 2100    Titans    AFC      
## 6 https://github.com/nflv… WAS       http… Washingt… 5110    Commande… NFC

Extenal images

We can bring in external images like team logos with with gt_img_rows.

We do this by specifying the columns to place the image, height (or width) to make sure it fits nicely in the table, and possibly img_source for technical purposes.

 logo_table <- team_df %>%
   gt() %>%
   gt_img_rows(columns = team_wordmark, height = 25) %>%
   gt_img_rows(columns = logo, img_source = "web", height = 30)

logo_table

team_wordmark	team_abbr	logo	team_name	team_id	team_nick	team_conf
	SEA		Seattle Seahawks	4600	Seahawks	NFC
	SF		San Francisco 49ers	4500	49ers	NFC
	STL		St. Louis Rams	2510	Rams	NFC
	TB		Tampa Bay Buccaneers	4900	Buccaneers	NFC
	TEN		Tennessee Titans	2100	Titans	AFC
	WAS		Washington Commanders	5110	Commanders	NFC

See also:

See also:

• the great_tables Python library - https://posit-dev.github.io/great-tables/get-started/
• formatting cells into things with money signs and commas with fmt_currency